home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 5 / Apprentice-Release5.iso / Source Code / Pascal / Snippets / vListMngr 1.0 / Docs.Text next >
Encoding:
Text File  |  1996-04-10  |  21.3 KB  |  14 lines  |  [TEXT/ttxt]
  1. SUMMARY
  2. vListMngr is a package of Pascal routines which implement creation and management of Lists with 
  3. variable column width, and up to four lines of header text per column.  The column headers behave 
  4. like spreadsheet headings, staying fixed on the screen while the cells scroll vertically, and tracking 
  5. the columns when cells are scrolled horizontally.  vListMngr also provides utilities for multiple cell 
  6. selection and copying and editing cell text.  The programming interface to vListMngr is very 
  7. similar to that of the standard List Manager, and existing programs will require very little 
  8. modification to incorporate the new features.  However, this version of vListMngr does not 
  9. support some standard List Manager capabilities, such as custom LDEF's, the Search function, or 
  10. selection flags.  
  11.  
  12. The archive contains a 68K demo program, documentation, and THINK Pascal source code for 
  13. vListMngr and the demo program.  The package was written to provide flexible entry of fairly 
  14. large tables of data for scientific instrument control systems and has been tested on several 68000 - 
  15. 68040 machines under System 6, System 7.1, and System 7.5.  The code may be used, modified, 
  16. and distributed freely provided that no profit is derived therefrom and the author is duly credited.
  17.  
  18. INTRODUCTION
  19. The Macintosh OS List Manager is a very handy tool for displaying and manipulating relatively 
  20. large amounts of data in a table format.  However, the standard List Manager has limitations which 
  21. make it ineffective in certain cases.  Only fixed size data cells can be used, which makes display of 
  22. data elements which vary significantly in size rather awkward.  Standard Lists lack headings which 
  23. let the user keep track of what the various columns and rows in the list represent.  There is also no 
  24. built-in mechanism for editing cell contents.  The latter two problems can be overcome by 
  25. supplying routines which coordinate display of headings with the list display, and routines which 
  26. keep Text Edit record(s) coordinated with the list selection(s), but these are cumbersome 
  27. programming tasks.  vListMngr was written because I needed to be able to enter large amounts of 
  28. tabular data in programs for scientific instrument control systems, and I needed variable-width 
  29. columns and column headings to produce a functional user interface.  Built-in support of text 
  30. editing and provision for multi-cell copy/paste were added for convenience.
  31.  
  32. THE CODE
  33. I started with the data structures and routine descriptions for List Manager given in Inside 
  34. Macintosh.  New data fields were added and code was written to implement the described routines.  
  35. Although the code is completely original, the functionality and syntax of the standard List Manager 
  36. calls has been preserved wherever possible.  vListMngr can therefore support most existing List 
  37. Manager code fairly transparently, and only the additional capabilities needed for the application 
  38. need to be learned and used.  However, not all List Manager calls have been implemented in this 
  39. version of vListMngr (see routine descriptions below).  In addition, the selection algorithms, user 
  40. LDEF's, and user LClickLoop routines are NOT supported.  All the routines available are listed 
  41. below, but only the new or altered calls are described in detail.  Please refer to Inside Macintosh 
  42. for descriptions of the standard List Manager calls.  The unimplemented calls are present as stubs, 
  43. so they will compile but will simply return without taking any action.  The code is sparsely 
  44. commented and gives some clue to what is going on.
  45.  
  46. SUPPORT/COMMENTS
  47. As will no doubt be apparent from the code, I am not a professional programmer.  I will gladly 
  48. provide any assistance within my capabilities, including bug fixes, improvements, and extensions 
  49. to the package.  The demo has been tested on a number of 68K machines under system 7.1 and 
  50. 7.5.  The routines don't do anything fancy, so they should perform appropriately in other 
  51. environments.  Please send communications to:
  52. Jeff Brewster
  53. jbrewster@arserrc.gov
  54.  
  55. USING vListMngr
  56. Minimal Operation
  57. 1.    Create a new vListRecord by calling vLNew. 
  58. The list created will have uniform cell dimensions, will use the existing font, and will have no 
  59. headings or built-in Text Edit record.
  60. 2.    Process mouse clicks in the list or its scroll bars by calling vLClick.
  61. 3.    Process update events in the window by calling vLUpdate.
  62. 4.    When done with the list call vLDispose
  63.  
  64. Full Operation
  65. 1.    Create a new vListRecord by calling vLNew. 
  66. The list created will have uniform cell dimensions, will use the existing font, and will have no 
  67. headings or built-in Text Edit record.
  68. 2.    Set up the headings by calling vLSetHeadings.  
  69. 3    Set the list and heading fonts with calls to vLSetListFont and vLSetHeadFont.
  70. 4.    Set the heading widths by calling vLSetWidths  OR  let vListMngr calculate the cell widths by 
  71. calling vLCalcCellWidths before calling vLSetWidths.
  72. 5.    Associate a TextEdit Record with the selected cell by calling vLTENew.
  73. 6.    Call vLNewScrap to create a new vLScrapHandle to support cutting and pasting. 
  74. 7.    Process mouse clicks in the list by calling vLClick.
  75. 8.    Process keypresses in the window by calling vLKey
  76. 9.    Process update events in the window by calling vLUpdate.
  77. 10.    When done with the list call vLDispose
  78.  
  79. Summary of the vListMngr Package
  80.  
  81. vListMngr Data
  82.  
  83. const
  84. maxCols = 31;
  85. maxChars = 16000;
  86. maxOffsets = 4095;
  87.  
  88. type
  89. Cell = Point;
  90.  
  91. EditModeType = (editCell, editTE);
  92.  
  93. DataArray = packed array[0..maxChars] of CHAR;
  94. DataPtr = ^DataArray;
  95. DataHandle = ^DataPtr;
  96.  
  97. OffsetArray = array[0..maxOffsets] of INTEGER;
  98.  
  99. lHeadArray = array[1..4] of STR255;
  100.  
  101. WidthArray = array[0..maxCols] of INTEGER;
  102.  
  103. modifierType = (none, command, option, control, shift);
  104.  
  105. vLScrapHandle = ^vLScrapPtr;
  106. vLScrapPtr = ^vListScrapRec;
  107. vListScrapRec = record
  108. scrapBounds: RECT;
  109. scrapData: dataArray;
  110. scrapOffsets: offsetArray;
  111.   end;
  112.  
  113. vListHandle = ^vListPtr;
  114. vListPtr = ^vListRec;
  115. vListRec = record
  116. rView: RECT;    {rectangle in which list heading and are viewed}
  117. port: GrafPtr;    {Grafport that owns us}
  118. indent: Point;    {Indent pixels in cell}
  119. cellSize: Point;    {Cell width and height (width is generally ignored)}
  120. visible: RECT;    {visible row/column bounds}
  121. vScroll: ControlHandle;    {vertical scroll bar (or NIL)}
  122. hScroll: ControlHandle;    {horizontal scroll bar (or NIL)}
  123. selFlags: SignedByte;    {defines selection characteristics}
  124. LActive: Boolean;    {active or not}
  125. LReserved: SignedByte;    {internally used flags}
  126. listFlags: SignedByte;    {other flags}
  127. clikTime: LONGINT;    {save time of last click}
  128. clikLoc: Point;    {save position of last click}
  129.  mouseLoc: Point;    {current mouse position}
  130. lClikLoop: Ptr;    {routine called repeatedly during ListClick}
  131. lastClick: Cell;    {the last cell clicked in}
  132. refCon: LONGINT;    {reference value}
  133. listDefProc: HANDLE;    {Handle to the defProc}
  134. userHandle: HANDLE;    {General purpose handle for user}
  135. dataBounds: RECT;    {Total number of rows/columns}
  136. cells: DataHandle;    {Handle to data}
  137. maxIndex: INTEGER;    {index past the last element = length of cellArray}
  138. cellArray: OffsetArray;    {offsets to elements  up to 32 cols and 128 rows}
  139. cellWidth: WidthArray;    {array of cell widths}
  140. lView: RECT;    {Rect in which list alone is viewed}
  141. frameWidth: INTEGER;    {width of frame around cells}
  142. just: INTEGER;    {text justification mode}
  143. lFont, lSize: INTEGER;    {list font info}
  144. lFace: Style;    {list font info}
  145. nhRows: Integer;    {# rows in heading}
  146. lHead: lHeadArray;    {heading text}
  147. hFont, hSize: INTEGER;    {heading font info}
  148. hFace: Style;    {heading font info}
  149. hCellHeight: INTEGER;    {height of heading cell}
  150. listTE: TEHandle;    {edit TE}
  151. lActiveTE: BOOLEAN;    {is the TE active?}
  152. lEditMode: BOOLEAN;    {are we editing a TE?}
  153.   end;
  154.  
  155.  
  156. Creating and Disposing of Lists
  157. Standard
  158. FUNCTION    vLNew    (plView, pdatabounds: RECT; cellSize: POINT; 
  159. procID: INTEGER; theWindow: WindowPtr; 
  160. drawIt, hasGrow, scrollHoriz, scrollVert: Boolean): 
  161. vListHandle;
  162. PROCEDURE    vLDispose    (vlHandle: vListHandle);
  163.  
  164. Adding and Deleting Rows and Columns
  165. Standard
  166. FUNCTION    vLAddRow    (count, rowNum: Integer; vlHandle: vListHandle): 
  167. Integer;
  168. PROCEDURE    vLDelRow    (count, rowNum: Integer; vlHandle: vListHandle);
  169. Unimplemented
  170. FUNCTION    vLAddColumn    (count, colNum: Integer; vlHandle: vListHandle): 
  171. Integer;
  172. PROCEDURE    vLDelColumn    (count, colNum: Integer; vlHandle: vListHandle);
  173.  
  174. Operations on Cells
  175. Standard
  176. PROCEDURE    vLClrCell    (theCell: Cell; vlHandle: vListHandle);
  177. PROCEDURE    vLGetCell    (dataPtr: Ptr; var dataLen: Integer; theCell: Cell; 
  178. vlHandle: vListHandle);
  179. PROCEDURE    vLSetCell    (dataPtr: Ptr; dataLen: Integer; theCell: Cell; 
  180. vlHandle: vListHandle);
  181. FUNCTION    vLGetSelect    (next: Boolean; var theCell: Cell; vlHandle: 
  182. vListHandle): Boolean;
  183. PROCEDURE    vLSetSelect    (setIt: Boolean; theCell: Cell; vlHandle: 
  184. vListHandle);
  185. New
  186. PROCEDURE    vLCalcCellWidths    (var newWidth: widthArray; var nCol: INTEGER; 
  187. vlHandle: vListHandle);
  188. PROCEDURE    vLSetHeadings    (nRows: INTEGER; headings: lHeadArray; 
  189. vlHandle: vListHandle);
  190. PROCEDURE    vLSetWidths    (widths: widthArray; vlHandle: vListHandle);
  191. PROCEDURE    vLKey    (ch: CHAR; modifiers: Integer; vlHandle: 
  192. vListHandle; vScrap: vLScrapHandle);
  193. PROCEDURE    vLTENew    (active: BOOLEAN; whatCell: Cell; vlHandle: 
  194. vListHandle);
  195. PROCEDURE    vLTEDispose    (vlHandle: vListHandle
  196.  
  197. Unimplemented
  198. PROCEDURE    vLAddToCell    (dataPtr: Ptr; dataLen: Integer; theCell: Cell; 
  199. vlHandle: vListHandle);    ***
  200. Mouse Location
  201. FUNCTION    vLClick    (pt: Point; modifiers: Integer; vlHandle: 
  202. vListHandle): Boolean;
  203. FUNCTION    vLLastClick    (vlHandle: vListHandle): Cell;
  204.  
  205. Accessing Cells
  206. Standard
  207. FUNCTION    vLNextCell    (hNext, vNext: Boolean; var theCell: Cell; vlHandle: 
  208. vListHandle): Boolean;
  209. PROCEDURE    vLFind    (var offset, len: Integer; theCell: Cell; vlHandle: 
  210. vListHandle);
  211. PROCEDURE    vLRect    (var cellRect: Rect; theCell: Cell; vlHandle: 
  212. vListHandle);
  213. New
  214. FUNCTION    vLEncloseSel    (vlHandle: vListHandle): Rect;
  215. PROCEDURE    vLCellsToScrap    (whatCells: RECT; vlHandle: vListHandle; hScrap: 
  216. vLScrapHandle);
  217. PROCEDURE    vLScrapToCells    (whatCells: RECT; vlHandle: vListHandle; hScrap: 
  218. vLScrapHandle);
  219. Unimplemented
  220. FUNCTION    vLSearch    (dataPtr: Ptr; dataLen: Integer; SearchProc: Ptr; var 
  221. theCell: Cell; vlHandle: vListHandle): Boolean;
  222.  
  223. List Display
  224. Standard
  225. PROCEDURE    vLActivate    (act: Boolean; vlHandle: vListHandle);
  226. PROCEDURE    vLDoDraw    (drawIt: Boolean; vlHandle: vListHandle);
  227. PROCEDURE    vLDraw    (theCell: Cell; vlHandle: vListHandle);
  228. PROCEDURE    vLScroll    (dRows, dCols: Integer; vlHandle: vListHandle);
  229. PROCEDURE    vLSize    (listWidth, listHeight: Integer; vlHandle: 
  230. vListHandle);
  231. PROCEDURE    vLUpdate    (theRgn: RgnHandle; vlHandle: vListHandle);
  232. New
  233. PROCEDURE    vLDrawHeading    (vlHandle: vListHandle);
  234. PROCEDURE    vLFont    (myFont, mySize: INTEGER; myFace: Style; 
  235. vlHandle: vListHandle);
  236. PROCEDURE    vLFrame    (frameWidth: INTEGER; var vlHandle: 
  237. vListHandle);
  238. PROCEDURE    vLIndent    (indent: POINT; var vlHandle: vListHandle);
  239. PROCEDURE    vLInsetList    (dH, dV: Integer; vlHandle: vListHandle);
  240. PROCEDURE    vLJust    (just: INTEGER; var vlHandle: vListHandle);
  241. PROCEDURE    vLUpdateSelRect    (selRect: Rect; vlHandle: vListHandle);
  242. Unimplemented
  243. PROCEDURE    vLAutoScroll    (vlHandle: vListHandle);
  244.  
  245. ROUTINE DESCRIPTIONS
  246.  
  247. Creating and Disposing of Lists
  248. FUNCTION    vLNew    (plView, pdatabounds: RECT; cellSize: POINT; procID: INTEGER; 
  249. theWindow: WindowPtr; drawIt, hasGrow, scrollHoriz, scrollVert: Boolean): 
  250. vListHandle;
  251. This function returns a handle to a new vList record.  The list font defaults to theWindow's font, 
  252. and the number of heading rows is set to 0.  If cellSize.h is 0, the cell width is calculated by 
  253. dividing the width of plView by databounds.right.  If cellSize.v is 0, the cell height is calculated 
  254. from the font information.
  255.  
  256.  
  257. Operations on Cells
  258. PROCEDURE    vLCalcCellWidths    (var newWidth: widthArray; var nCol: INTEGER; vlHandle: 
  259. vListHandle);
  260. vLCalcCellWidths returns in nCol the number of columns and in newWidths the widths of 
  261. columns as calculated from the current heading string(s) (set previously by vLSetHeadings).  The 
  262. calculation is based on parsing the heading string into substrings using the '|' character as a 
  263. delimiter.  The width of each substring in pixels is determined using the StringWidth function and 
  264. the current heading font, and the resulting value is returned as the width of the respective column.  
  265. If a substring is blank, then the width of that column is not changed from its previous value.  Thus 
  266. headings can be supplied to only a few columns.  If there are multiple heading rows, the width of 
  267. the widest row in the column is used.  If an integer n is the first non-space character of a heading 
  268. substring, that substring is centered over n columns in the row(s) beneath.  Otherwise the heading 
  269. is centered in its column.
  270.  
  271. For example, the following heading strings: 
  272.  
  273. TTHead1 = 'Time  |        2Power      |      5Valves           |';
  274. TTHead2 = ' min   | Volts | mAmps | A | B | C | D | E |';
  275.  
  276. are parsed to yield this heading:
  277.  
  278.  Time        Power           Valves
  279.  min    Volts   mAmps    A  B  C  D  E
  280.  
  281. The values returned by vLCalcCellWidths generally give an attractive appearance to the table.  To 
  282. actually change the column widths it is necessary to call vLSetWidths with the returned array.
  283.  
  284. PROCEDURE    vLSetHeadings    (nRows: INTEGER; headings: lHeadArray; vlHandle: 
  285. vListHandle);
  286.  
  287. Sets the heading strings and number of heading rows appropriately.  The top of lView is 
  288. recalculated so as to fit the heading into rView.  The list and headings are redrawn.
  289.  
  290.  
  291. PROCEDURE    vLTENew    (active: BOOLEAN; whatCell: Cell; vlHandle: vListHandle);
  292.  
  293. Creates a new TERec associated with the list and used to edit cell contents.  If active is TRUE, then 
  294. the contents of whatCell are displayed in and cell editing is enabled.
  295.  
  296. PROCEDURE    vLTEDispose    (vlHandle: vListHandle);
  297.  
  298. Disposes of the TERec associated with the list and sets listTE to nil.
  299.  
  300. PROCEDURE    vLKey    (ch: CHAR; modifiers: Integer; vlHandle: vListHandle; vScrap: 
  301. vLScrapHandle);
  302.  
  303. vLKey handles keypresses in the list, performing editing functions (copy, cut, paste) on selected 
  304. cells and/or list navigation (return, enter, tab, arrow keys).  If a TERec is associated with the list, 
  305. and cell text editing is activated, then most keypresses are passed to TEKey.  In this mode, return 
  306. or enter cause the contents of the TERec to be transferred to the active cell, and selection of the next 
  307. cell in the list.  In this mode, tab and arrow keys cause the original contents of the cell to be 
  308. restored, followed by appropriate navigation activity.
  309.  
  310.  
  311. Mouse Location
  312. FUNCTION    vLClick    (pt: Point; modifiers: Integer; vlHandle: vListHandle): Boolean;
  313.  
  314. vLClick handles mouse-down events in the list and its scroll bars, returning TRUE if there was a 
  315. double click in a cell, and FALSE otherwise.  Cells are selected according the the current mouse 
  316. position as follows:
  317. Shift Click    Add clicked cell to existing selection.
  318. Shift Drag    Extend selection to the currently selected cell.
  319. Option Click    Select the clickedrow.
  320. Control Click    Select the clicked column.
  321. If there is a TERec associated with the list (listTE <> nil) then editing of of cell contents is activated 
  322. by double clicking in a cell.  Once activated, further clicks in the cell are passed to TEClick. 
  323. Clicking outside the active cell terminates editing, restores the original cell contents, and selects the 
  324. clicked cell. 
  325.  
  326. Accessing Cells
  327. FUNCTION    vLEncloseSel    (vlHandle: vListHandle): RECT;
  328.  
  329. vLEncloseSel returns the smallest rectangle which encloses all selected cells.  This is useful for 
  330. processing multiple cell selections outside of vListMngr.
  331.  
  332.  
  333. PROCEDURE    vLCellsToScrap    (whatCells: RECT; vlHandle: vListHandle; hScrap: 
  334. vLScrapHandle);
  335.  
  336. vLCellsToScrap copies the data bounded by whatCells to hScrap.  The transferred data are within 
  337. whatCells, i.e. whatCells.right is 1 greater than rightmost cell index.  The cell data are not 
  338. neccesarilly contiguous.  This routine is generally called when a Cut or Copy command is being 
  339. processed on a group of selected cells.   It can also be used to transfer data from a list into a file for 
  340. storage.
  341.  
  342.  
  343. PROCEDURE    vLScrapToCells    (whatCells: RECT; vlHandle: vListHandle; hScrap: 
  344. vLScrapHandle);
  345.  
  346. vLScrapToCells copies the data in hScrap to the the cells bounded by whatCells.  The transferred 
  347. data are within whatCells, i.e. whatCells.right is 1 greater than rightmost cell index.  This routine 
  348. is generally called when a Paste command is being processed on a group of selected cells.  It can 
  349. also be used to transfer data from a file into a list.
  350.  
  351.  
  352. List Display
  353. PROCEDURE    vLDrawHeading    (vlHandle: vListHandle);
  354.  
  355. Draws the heading(s) using the current heading font and style.
  356.  
  357. PROCEDURE    vLFont    (myFont, mySize: INTEGER; myFace: Style; vlHandle: 
  358. vListHandle);
  359.  
  360. Set the List font.
  361.  
  362. PROCEDURE    vLFrame    (frameWidth: INTEGER; var vlHandle: vListHandle);
  363.  
  364. Set the width of the frame drawn around cells.  The frame rectangle is drawn so that
  365. the top and left edges are "inside" the cell rectangle, while the bottom and right edges begin one 
  366. pixel "outside" the cell rectangle.  The view rectangle should be sized to allow drawing of the 
  367. frame to get the best appearance.
  368.  
  369. PROCEDURE    vLIndent    (indent: POINT; var vlHandle: vListHandle);
  370.  
  371. Set the cell indent.
  372.  
  373.  
  374. PROCEDURE    vLInsetList    (dH, dV: Integer; vlHandle: vListHandle);
  375.  
  376. Change the size of the display rectangle by dH, dV.  Similar to vLSize, but simpler to use when 
  377. resizing windows.
  378.  
  379.  
  380. PROCEDURE    vLJust    (just: INTEGER; var vlHandle: vListHandle);
  381.  
  382. Set the justification mode for cell text.
  383.  
  384.  
  385. PROCEDURE    vLUpdateSelRect    (selRect: Rect; vlHandle: vListHandle);
  386.  
  387. Selects all cells bounded by selRect and unselects all other cells in the list.  Redraws any cells 
  388. which change select status}
  389.  
  390.  
  391. u
  392. ‡∂åb8EÔEÚ˝˜
  393. @iÃ4ú˙X¥()É·H•
  394.  w€B¶
  395. hÀ    &    á    Ë
  396. G
  397. ì
  398. î
  399. ù
  400. ˚ ^ √ $ à È
  401. N
  402. Æx÷    
  403. {›9ÊÁ˜    8ö¡ HrsDZ:mΩTû(]ôƒ≈ÊÁˆ˜˝ 016DEhiòÆ≈Δı˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚ˆ˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚$ê $ê aıˆFGÄù∫—‰˙6L^ú√Í0[íÀ'V{®÷>jç∫!Eå÷6ií∫Ÿ˛ Kmú∏‡ 4=z¢◊‰   7 @ Ñ ç — fl!&!/!v!w!ã!î!–""1"v"é"—"Ë#)#7#;#Ö#ù#›#ı$8$r$ó$÷$‰%%˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚$ê c%% %g%É%í%Œ%Â&&&*&3&}&î&⁄&Ë'('6':'o'∫' ((%(3(|(¨(≠(∫(√(ˇ)<)u)∏)ı**B*F*w*≤* +++N+é+À,
  404. ,,K,L,a,b,Ç,–--(-å-Ó.T.o.p.q.Ö.Ÿ.Á/>/†00e0Ã121ï1˚2_2z2{2®2©2Ï3&3'3I3J3n3ï3ñ3˘4X4Y4£4±4≤5 5a5b5c5Ø5∞6˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚ˆ˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚ˆ˚˚˚˚˚˚˚˚˚$ê $ê a66^6_6é6è6÷6◊7&76777ö88h8“959l9m9n9}9œ9–:2:î:©:›;;=;f;“<4<ü<Æ<Ø<ø<Ù<ı=Y=ì=î=ï=‡==Ò>R>≤??~?á?à?â?‘?‰?Â@G@ÆAAHAIAJAWAàAâA»A…BBBB0B1BuBvBÀC/CêC≤C≥CÚCÛDD    D
  405. DJDKD¨DæDøD¿D˝D˛E(E)E*ElEmE—EÌ˚˚˚˚˚˚ˆ˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚˚ÒÒÒÒÒÒÒÒÒÒÒÒÒÒÒÒÒÒÒÒÒÒÒÒÒÒÒÒÒÒÒÒÒÒÒÒÒÒÒÒÒÒÒÒÒÒÒÒÒÒÒÒÒÒÒ$ê $ê _EÌEÓEÔ˚˚
  406. fiDÔEÔÁ—‰&∫1_:f<YAÀDÔˇˇˇˇˇˇ-ˇˇˇˇˇˇlPˇˇ@ˇˇ
  407. dPˇˇ EÚ#ı%6EÌEÔ$%&'(
  408. !"Ä∞–—“”‘’÷◊ÿ⁄€·ËÌÙˆ¯˛    ”&p&r9€:~HH⁄(ˇ·ˇ‚˘FG(¸HH⁄(d'ê@=‡/–††††–R@H
  409. -:LaserWriter
  410. PalatinoTimesÄ    ä    äÄÄ    äEuEP